package com.lyc.utils;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import okhttp3.*;

import java.io.IOException;
import java.lang.reflect.Type;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.Map;

/**
 * HttpClient 类用于发送 HTTP 请求，特别是 POST 请求。
 */
public class HttpClient {

    /**
     * 创建一个 Gson 实例，使用下划线命名策略。
     */
    // private static final Gson policyGson = new GsonBuilder()
    //         .setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
    //         .create();
    private static final Gson policyGson = new Gson();

    /**
     * 定义请求体的媒体类型为 JSON。
     */
    public static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");

    /**
     * 创建一个 OkHttpClient 实例，用于发送 HTTP 请求。
     */
    private static final OkHttpClient client = new OkHttpClient();

    /**
     * 发送 GET 请求并返回响应结果，支持设置请求头和查询参数。
     *
     * @param httpUrl 请求的 URL
     * @param params 请求参数，以 Map 形式提供
     * @param headers 请求头，以 Map 形式提供
     * @return 响应结果字符串
     */
    public static String doGet(String httpUrl, Map<String, Object> params, Map<String, String> headers) {
        // 构建查询字符串
        StringBuilder queryBuilder = new StringBuilder();
        for (Map.Entry<String, Object> entry : params.entrySet()) {
            if (queryBuilder.length() > 0) {
                queryBuilder.append("&");
            }
            queryBuilder.append(URLEncoder.encode(entry.getKey(), StandardCharsets.UTF_8))
                    .append("=")
                    .append(URLEncoder.encode(String.valueOf(entry.getValue()), StandardCharsets.UTF_8));
        }

        // 构建完整的 URL
        String fullUrl = httpUrl + "?" + queryBuilder.toString();

        // 构建请求对象
        Request.Builder requestBuilder = new Request.Builder()
                .url(fullUrl)
                .get();

        // 如果有请求头，则添加请求头
        if (headers != null) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                requestBuilder.addHeader(entry.getKey(), entry.getValue());
            }
        }

        Request request = requestBuilder.build();

        // 发送请求并处理响应
        try (Response response = client.newCall(request).execute()) {
            // 打印响应头信息
            System.out.println("Response headers:\n" + response.headers());
            // 返回响应体内容
            return response.body().string();
        } catch (IOException e) {
            // 捕获并打印异常信息
            e.printStackTrace();
        }

        // 如果发生异常，返回空字符串
        return "";
    }

    /**
     * 发送 GET 请求并返回响应结果，支持设置请求头。
     *
     * @param httpUrl 请求的 URL
     * @param headers 请求头，以 Map 形式提供
     * @return 响应结果字符串
     */
    public static String doGet(String httpUrl, Map<String, String> headers) {
        // 构建请求对象
        Request.Builder requestBuilder = new Request.Builder()
                .url(httpUrl)
                .get();

        // 如果有请求头，则添加请求头
        if (headers != null) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                requestBuilder.addHeader(entry.getKey(), entry.getValue());
            }
        }

        Request request = requestBuilder.build();

        // 发送请求并处理响应
        try (Response response = client.newCall(request).execute()) {
            // 打印响应头信息
            System.out.println("Response headers:\n" + response.headers());
            // 返回响应体内容
            return response.body().string();
        } catch (IOException e) {
            // 捕获并打印异常信息
            e.printStackTrace();
        }

        // 如果发生异常，返回空字符串
        return "";
    }

    /**
     * 发送 POST 请求并返回响应结果。
     *
     * @param httpUrl 请求的 URL
     * @param params 请求参数，以 Map 形式提供
     * @return 响应结果字符串
     */
    public static String doPost(String httpUrl, Map<String, Object> params) {
        return doPost(httpUrl, params, null);
    }

    /**
     * 发送 POST 请求并返回响应结果，支持设置请求头。
     *
     * @param httpUrl 请求的 URL
     * @param params 请求参数，以 Map 形式提供
     * @param headers 请求头，以 Map 形式提供
     * @return 响应结果字符串
     */
    public static String doPost(String httpUrl, Map<String, Object> params, Map<String, String> headers) {
        Type type = new TypeToken<Map<String, Object>>(){}.getType();

        // 将参数对象转换为 JSON 字符串
        String json = policyGson.toJson(params, type);
        // System.out.println("JSON request body: " + json);

        RequestBody body = RequestBody.create(JSON, json);

        // 构建请求对象
        Request.Builder requestBuilder = new Request.Builder()
                .url(httpUrl)
                .post(body);

        // 如果有请求头，则添加请求头
        if (headers != null) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                requestBuilder.addHeader(entry.getKey(), entry.getValue());
            }
        }

        Request request = requestBuilder.build();

        // 发送请求并处理响应
        try (Response response = client.newCall(request).execute()) {
            // 打印响应头信息
            // System.out.println("Response headers:\n" + response.headers());
            // 返回响应体内容
            return response.body().string();
        } catch (IOException e) {
            // 捕获并打印异常信息
            e.printStackTrace();
        }

        // 如果发生异常，返回空字符串
        return "";
    }

    /**
     * 发送 POST 请求并返回响应结果，仅需提供请求 URL。
     *
     * @param httpUrl 请求的 URL
     * @return 响应结果字符串
     */
    public static String doPost(String httpUrl) {
        // 构建请求对象
        Request request = new Request.Builder()
                .url(httpUrl)
                .post(RequestBody.create(JSON, "")) // 发送空的请求体
                .build();

        // 发送请求并处理响应
        try (Response response = client.newCall(request).execute()) {
            // 打印响应头信息
            System.out.println(response.headers());
            // 返回响应体内容
            return response.body().string();
        } catch (IOException e) {
            // 捕获并打印异常信息
            e.printStackTrace();
        }

        // 如果发生异常，返回空字符串
        return "";
    }
}
